package com.xm.util.old; /**
 * security.util.StringUtil.java
 * ----------------------------------------------------------
 *        author           date         version
 * ----------------------------------------------------------
 *      liu-guoping         2015-4-27        1.0.0
 * ----------------------------------------------------------
 * Copyright © 2015–2020 juchaosoft.com. All rights reserved.
 */

/*import com.dev.ncu.common.Constants;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Row;*/

import com.xm.common.Constants;

import java.io.UnsupportedEncodingException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Function： 字段串处理工具类
 * 
 * @author liu-guoping
 * 
 *         Time：下午1:17:14
 */
public class StringUtil {

	/**
	 * 判断字符串是否为null或空
	 * 
	 * @param str
	 *            待判断的字符串
	 * @return
	 */
	public static boolean isNullOrEmpty(String str) {
		if (str != null) {
			if (!"".equals(str.trim())) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 判断ID串中是否存在指定ID
	 * 
	 * @param ids
	 * @param id
	 * @return
	 */
	public static boolean isIdFixed(String ids, String id) {
		if (!isNullOrEmpty(ids) && !isNullOrEmpty(id)) {
			if (ids.startsWith(id + "_") || ids.indexOf("_" + id + "_") != -1 || ids.endsWith("_" + id)
					|| StringUtil.compare(ids, id) == 0) {
				return true;
			}
		}
		return false;
	}

	public static String iddReplace(String ids, String id) {
		if (!isNullOrEmpty(ids) && !isNullOrEmpty(id)) {
			ids = ids.replace("_" + id + "_", "_");

			if (ids.startsWith(id + "_")) {
				ids = ids.substring((id + "_").length());
			}

			if (ids.endsWith("_" + id)) {
				ids = ids.substring(0, ids.lastIndexOf("_" + id));
			}
		}
		return ids;
	}

	/**
	 * 
	 * @param ids
	 * @param id
	 * @return
	 */
	public static boolean isIdLeftFixed(String ids, String id) {
		if (ids != null) {
			if (ids.startsWith(id + "_") || ids.indexOf("#" + id + "_") != -1) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 模糊匹配上
	 * 
	 * @param src
	 * @param target
	 * @return
	 */
	public static boolean isApproxMatched(String src, String target) {
		if (!isNullOrEmpty(src) && !isNullOrEmpty(target)) {
			src = src.toLowerCase();
			target = target.toLowerCase();
			if (src.indexOf(target) != -1) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 比较两个字符串
	 * 
	 * @param str1
	 * @param str2
	 * @return
	 */
	public static int compare(String str1, String str2) {
		if (str1 == null) {
			if (str2 == null) {
				return 0;
			}
			return -1;
		} else {
			if (str2 == null) {
				return 1;
			}
			return str1.compareTo(str2);
		}
	}

	public static int compareIgnoreCase(String str1, String str2) {
		if (str1 == null) {
			if (str2 == null) {
				return 0;
			}
			return -1;
		} else {
			if (str2 == null) {
				return 1;
			}
			str1 = str1.toLowerCase();
			str2 = str2.toLowerCase();
			return str1.compareTo(str2);
		}
	}

	/**
	 * 字符串转换为整数
	 *
	 * @param obj
	 * @param defaultValue
	 * @return
	 */
	public static int toInt(Object obj, int defaultValue) {
		if (obj != null && !"".equals(obj)) {
			if (obj instanceof Integer) {
				return (Integer) obj;
			} else {
				try {
					return Integer.parseInt(obj.toString().trim());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return defaultValue;
	}

	/**
	 * 字符串转换为float
	 * 
	 * @param str
	 * @param defaultValue
	 * @return
	 */
	public static float toFloat(String str, float defaultValue) {
		if (!isNullOrEmpty(str)) {
			try {
				return Float.parseFloat(str.trim());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}

	/**
	 * 字符串转换为 double
	 * 
	 * @param str
	 * @param defaultValue
	 * @return
	 */
	public static double toDouble(String str, double defaultValue) {
		if (!isNullOrEmpty(str)) {
			try {
				return Double.parseDouble(str.trim());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}

	/**
	 * 字符串转换为long
	 * 
	 * @param str
	 * @param defaultValue
	 * @return
	 */
	public static long toLong(String str, long defaultValue) {
		if (!isNullOrEmpty(str)) {
			try {
				return Long.parseLong(str.trim());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}

	/**
	 * 字符串转换为boolean
	 * 
	 * @param str
	 * @param defaultValue
	 * @return
	 */
	public static boolean toBoolean(Object str, boolean defaultValue) {
		if (str != null) {
			try {
				return Boolean.parseBoolean(str.toString().trim());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}

	/**
	 * 字符串拆分成列表
	 * 
	 * @param str
	 * @param delim
	 * @return
	 */
	public static List<String> toList(String str, String delim) {
		List<String> list = new ArrayList<String>();
		if (!isNullOrEmpty(str) && !isNullOrEmpty(delim)) {
			str = str.trim();
			StringTokenizer stk = new StringTokenizer(str, delim);
			while (stk.hasMoreTokens()) {
				String spStr = stk.nextToken();
				if (!isNullOrEmpty(spStr)) {
					list.add(spStr);
				}
			}
		}
		return list;
	}

	/**
	 * 字符串转换成数组
	 * 
	 * @param str
	 * @param delim
	 * @return
	 */
	public static String[] toArray(String str, String delim) {
		List<String> list = toList(str, delim);
		if (!list.isEmpty()) {
			int size = list.size();
			String[] arr = new String[size];
			int c = 0;
			for (String cstr : list) {
				if (!isNullOrEmpty(cstr)) {
					arr[c++] = cstr;
				}
			}
			return arr;
		}
		return null;
	}

	/**
	 * 字符串列表转换成字符串数组
	 * 
	 * @param strList
	 * @return
	 */
	public static String[] toArray(List<String> strList) {
		if (strList != null && !strList.isEmpty()) {
			int size = strList.size();
			String[] arr = new String[size];
			int c = 0;
			for (String cstr : strList) {
				if (!isNullOrEmpty(cstr)) {
					arr[c++] = cstr;
				}
			}
			return arr;
		}
		return null;
	}

	/**
	 * 字符串转换成数组
	 * 
	 * @param str
	 * @param delim
	 * @return
	 */
	public static Map<String, String> toMap(String str, String delim) {
		Map<String, String> map = new HashMap<String, String>();
		if (!isNullOrEmpty(str) && !isNullOrEmpty(delim)) {
			str = str.trim();
			StringTokenizer stk = new StringTokenizer(str, delim);
			while (stk.hasMoreTokens()) {
				String spStr = stk.nextToken();
				if (!isNullOrEmpty(spStr)) {
					map.put(spStr, spStr);
				}
			}
		}
		return map;
	}

	/**
	 * 数组转换成字符串
	 * 
	 * @param data
	 * @return
	 */
//	public static String getString(byte[] data) {
//		return getString(data, Constants.DEFAULT_ENCODING);
//	}

	/**
	 * 
	 * @param data
	 * @param encoding
	 * @return
	 */
	public static String getString(byte[] data, String encoding) {
		try {
			return new String(data, encoding);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 字符串转换成byte数组
	 * 
	 * @param str
	 *            待转换的字符串
	 * @param encoding
	 *            编码
	 * @return
	 */
	public static byte[] getBytes(String str, String encoding) {
		if (str == null) {
			str = "";
		}
		try {
			return str.getBytes(encoding);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/*public static String getCellValue(Cell cell) {
		if (null == cell) {
			return "";
		}
		switch (cell.getCellType()) {
		case Cell.CELL_TYPE_STRING:
			return cell.getRichStringCellValue().getString().trim();
		case Cell.CELL_TYPE_NUMERIC:
			if (DateUtil.isCellDateFormatted(cell)) {
				// 日期，返回的格式为 精确到毫秒的完整时间 如：yyyy-MM-dd HH:mm:ss.S
				return com.dev.ncu.util.DateUtil.format(cell.getDateCellValue(),
						com.dev.ncu.util.DateUtil.DEFAULT_FULL_PATTERN);
			} else {
				return cell.getNumericCellValue() + "";
			}
		case Cell.CELL_TYPE_BOOLEAN:
			return cell.getBooleanCellValue() + "";
		default: // 单元格类型为公司，空，错误的都返回一个空字符串。
			return "";
		}
	}*/

	// 判断是否是正确的导入模板
	/*public static boolean isCorrectTemplate(Row firstRow, String[] titles) {
		for (int i = 0; i < titles.length; i++) {
			Cell cell = firstRow.getCell(i);
			String title = getCellValue(cell);
			// 如果标题不相等，则说明模板不正确。
			if (!titles[i].equals(title)) {
				return false;
			}
		}
		return true;
	}*/

	// 判断导入这一行的数据是否整一行都为空
	// @param length为有多少列
	/*public static boolean isEmptyRow(Row row, int columnLength) {
		if (null == row) {
			return true;
		}
		for (int i = 0; i < columnLength; i++) {
			Cell cell = row.getCell(i);
			String value = getCellValue(cell);
			if (!"".equals(value)) {
				return false;
			}
		}
		return true;
	}*/

	/**
	 * 判断是否是办公电话(手机号码和固定电话，目前只是个大概的验证)
	 * 
	 * @param phone
	 * @return
	 */
	public static boolean isTelephone(String phone) {
		Pattern pattern = Pattern.compile("[0-9()（）+-]{1,20}");
		Matcher matcher = pattern.matcher(phone);
		return matcher.matches();
	}

	// 判断字符的长度是否大于50，大于则返回true，否则返回false
	public static boolean isStrLengthGtN(String string, int n) {
		return string.length() > n ? true : false;
	}

	/**
	 * 使用默认UTF-8编码将字符串转换成byte数组
	 * 
	 * @param str
	 * @return
	 */
	public static byte[] getBytes(String str) {
		return getBytes(str, Constants.DEFAULT_ENCODING);
	}

	public static String toString(Object object) {
		if (object != null) {
			return object.toString();
		}
		return "";
	}
	
	public static String toUtf8String(String string) { 
	     
        StringBuffer sb = new StringBuffer(); 
        
        for (int i = 0; i < string.length(); i++) { 
            char c = string.charAt(i); 
            if (c >= 0 && c <= 255) { 
                sb.append(c); 
            } else { 
                byte[] b; 
                try { 
                    b = Character.toString(c).getBytes("utf-8"); 
                } catch (Exception e) { 
                    e.printStackTrace();
                    b = new byte[0]; 
                } 
                for (int j = 0; j < b.length; j++) { 
                    int k = b[j]; 
                    if (k < 0) 
                        k += 256; 
                    sb.append("%" + Integer.toHexString(k).toUpperCase()); 
                } 
            } 
        } 
        return sb.toString(); 
    } 
	/**
	 * 剔除字符串中含有的空格字符、单引号、双引号
	 * @param str
	 * @return
	 */
	public static String format1(String str){
		if(str==null)return null;
		 str = str.replace(" ", "");
		 str = str.replace("'", "");
		 str = str.replace("\"", "");
		 return str;
	}
	
	/**
	 * 把ID串（纯字母大小写和数字组成）格式化为可直接引用的INsql
	 * @param str
	 * @return
	 */
	public static String format2(String str,String newseparator,String oldseparator){
		if(str==null)return null;
		if(str.indexOf("'")!=-1)return str;
		 str = str.replace(" ", "");
		 str = str.replace(oldseparator, newseparator);
		 return str;
	}
	/**
	 * 去除ID串尾部  suffix
	 * @param str
	 * @return
	 */
	public static String format3(String str,String suffix){
		if(str!=null && str.endsWith(suffix)){
			return str.substring(0, str.length()-1);
		}
		return str;
	}
	/**
	 * 把ID为整型的ID串格式化转成可以直接引用的in内容
	 * @param str
	 * @param separator 原单个ID将的分隔符
	 * @return
	 */
	public static String intToInsql(String str,String separator){
		if(StringUtil.isNullOrEmpty(str))return str;
		 str = str.replace(" ", "");
		 str = str.replace("'", "");
		 str = str.replace("\"", "");
		if(str.endsWith(separator)){
			str = str.substring(0, str.length()-1);
		}
		return str;
	}
	/**
	 * 把ID为字符串型的ID串格式化转成可以直接引用的in内容
	 * @param str
	 * @param separator 原单个ID将的分隔符
	 * @return
	 */
	public static String strToInsql(String str,String separator){
		if(StringUtil.isNullOrEmpty(str))return str;
		 str = str.replace(" ", "");
		 str = str.replace("'", "");
		 str = str.replace("\"", "");
		if(str.endsWith(separator)){
			str = str.substring(0, str.length()-1);
		}
		str = str.replace(separator, "','");
		str = "'" + str + "'";
		return str;
	}
	/**
	 * 字符串列表转换成整型列表
	 * 
	 * @param str
	 * @param delim
	 * @return
	 */
	/*public static List<Integer> toIntList(String str, String delim) {
		List<String> list = toList(str, delim);
		List<Integer> intlist = new ArrayList<>();
		if (!list.isEmpty()) {
			for (String cstr : list) {
				if (!isNullOrEmpty(cstr)) {
					intlist.add(security.util.StringUtil.toInt(cstr, 0));
				}
			}
			return intlist;
		}
		return null;
	}*/
	/**
	 * 获取两个字符串列表的交集
	 * 默认两个字符串列表中各自内部的值都是唯一的，否则结果查找与第一个字符列表一致 如list1有两个“A”，list2有一个“A”，结果返回两个A
	 * @return
	 */
	public static List<String> getIntersection(List<String> strList1,List<String> strList2){
		if(strList1 == null || strList1.isEmpty() || strList2 == null || strList2.isEmpty()){
			return null;
		}
		List<String> resList = new ArrayList<>();
		for(String str1 : strList1){
			for(String str2 : strList2){
				if(str1.equals(str2)){
					resList.add(str1);
					break;
				}
			}
		}
		return resList;
	}
	
	/**
	 * 
	 * @param string 变量值
	 * @param table 表名
	 * @param variable 字段名
	 * @return
	 */
	public static String stringToSql(String string,String table,String variable,int type) {
		if(StringUtil.isNullOrEmpty(string)){
			return "";
		}
		if(string.indexOf(";") != -1){
			return "";
		}
		StringBuffer sb = new StringBuffer();
		List<String> list = StringUtil.toList(string, ",");
		int size = list.size();
		variable = table + "." + variable;
		sb.append("(");
		for(int i = 0;i < size ;i++){
			if(i != 0){
				sb.append(" or ");
			}
			sb.append(variable);
			sb.append(" = ");
			if(type == 1 && string.indexOf("'") == -1){
				sb.append("'");
			}
			sb.append(list.get(i).trim());
			if(type == 1 && string.indexOf("'") == -1){
				sb.append("'");
			}
		}
		sb.append(")");
		return sb.toString();
	}
	
	/**
	 * 剔除字符串中含有的空格字符
	 * @param str
	 * @return
	 */
	public static String trim(String str){
		if(str==null || str == ""){
			return null;
		}
		str = str.replace(" ", "");
		return str;
	}
	
	/**
	 * 
	 */
	public static String getFenxiaoRight(String params,String right) {
		if(StringUtil.isNullOrEmpty(params)){
			if(right == "all"){
				params = "";
			}else if(StringUtil.isNullOrEmpty(right)){
				params = "0";
			}else{
				
				params = right;
			}
		}
		return params;
	}
	
	/**
     * 将list转化为字符串
     * @param list
     * @param separator 分割符
     * @return
     */
    public static String listToString(List<String> list,String separator) {
    	StringBuffer str = new StringBuffer();
    	if(list!=null) {
    		for (String val : list) {
    			if(str.length()>0) {
    				str.append(separator);
    			}
    			str.append(val);
    		}
    	}
    	return str.toString();
    }
    
    /**
	 * 判断obj是否为null或空
	 * 
	 * @param obj 待判断的字符串
	 * @return
	 */
	public static boolean nullOrEmpty(Object obj) {
		if (obj != null) {
			if (!"".equals(obj.toString().trim())) {
				return false;
			}
		}
		return true;
	}
	
	/**
	 * 字符串拆分成列表（去重）
	 * 
	 * @param str
	 * @param delim
	 * @return
	 */
	public static Set<String> toSet(String str, String delim) {
		Set<String> set = new HashSet<String>();
		if (!isNullOrEmpty(str) && !isNullOrEmpty(delim)) {
			str = str.trim();
			StringTokenizer stk = new StringTokenizer(str, delim);
			while (stk.hasMoreTokens()) {
				String spStr = stk.nextToken();
				if (!isNullOrEmpty(spStr)) {
					set.add(spStr);
				}
			}
		}
		return set;
	}
	
	/**
     * 将set转化为字符串
     * @param set
     * @param separator 分割符
     * @return
     */
    public static String setToString(Set<String> set,String separator) {
    	StringBuffer str = new StringBuffer();
    	if(set!=null) {
	    	for (String val : set) {
				if(str.length()>0) {
					str.append(separator);
				}
				str.append(val);
			}
    	}
    	return str.toString();
    }
    
	public static String objToStr(Object o) {
		if (null == o)
			return "";
		if (o instanceof String)
			return o.toString().trim();
		else
			return String.valueOf(o);
	}
	
	/**
     * 参数是否有一个为空
     * @param objs
     * @return
     */
	public static boolean anyNullorEmpty(Object... objs) {
		for (Object obj : objs)
			if(nullOrEmpty(obj))
				return true;
		return false;
	}
	
	/**
	 * 字符串转换为整数
	 * 
	 * @param obj
	 * @param defaultValue
	 * @return
	 */
	public static int toIntWhatever(Object obj, int defaultValue) {
		if (obj != null && !"".equals(obj)) {
			if (obj instanceof Integer) {
				return (Integer) obj;
			} else {
				try {
					return Integer.parseInt(obj.toString().trim());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return defaultValue;
	}
	
	/**
	 * 字符串转换为双浮点型数
	 * 
	 * @param obj
	 * @param defaultValue
	 * @return
	 */
	public static double toDoubleWhatever(Object obj, double defaultValue) {
		if (obj != null && !"".equals(obj)) {
			if (obj instanceof Double) {
				return (Double) obj;
			} else {
				try {
					return Double.parseDouble(obj.toString().trim());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return defaultValue;
	}
	
	/**
	 * 获取支持IN查询的拼接字符串
	 * @param obj
	 * @return
	 */
	public static String getInStr(Object obj){
		List<String> list = new ArrayList<>();
		if(!nullOrEmpty(obj)){
			String[] oArr = obj.toString().split(","); 
			for (String o : oArr) {
				if(!list.contains(o)){
					list.add("'" + o + "'");
				}
			}
		}
				
		return listToString(list, ",");
	}
	
}
